home *** CD-ROM | disk | FTP | other *** search
/ Software Vault: The Gold Collection / Software Vault - The Gold Collection (American Databankers) (1993).ISO / cdr49 / 274_01.zip / A_TESTAL.C < prev    next >
Text File  |  1993-04-01  |  14KB  |  674 lines
  1. /* Array Handling Package
  2. (C) Copyright 1985,1987,1988 James P. Cruse - All Rights Reserved
  3.  
  4. a_testall.c  
  5.  
  6. A Part of the User-Supported Array Handling package. Please see
  7. the file ARRAY.h for discussion concerning the registration and 
  8. usage of the package.
  9.  
  10. Tests all array functions 
  11.  
  12. */    
  13.  
  14. #include <stdio.h>
  15.  
  16. #include "array.h"
  17.  
  18.  
  19. /* which do you want to test? (some compilers can't handle them all at once) */
  20. #define    TEST_FILL    1
  21. #define    TEST_INFO    1
  22. #define    TEST_UNOP    1
  23. #define    TEST_BINOP    1
  24. #define    TEST_MOD    1         /* true if a legal % type */
  25. #define    ARRAY_TYPE    int                /* what type of array */
  26. #define    PRV(X)        printf("\t%d",(X))    /* print Value x */
  27.  
  28. #define    NUM        10          /* how many elements */
  29.                     /* NUM*NUM < maxint */
  30.  
  31.  
  32. a_error(msg,i)
  33. char *msg;
  34. ARRAY_TYPE i;
  35. {
  36. printf("\n\nERROR: '%s'\n\tIndex:",msg);
  37. PRV(i);
  38. puts("\n\nAborting\n");
  39. exit(-1);
  40. }
  41.  
  42. ARRAY_TYPE cnt = 0;
  43.  
  44. reset_zero_param()
  45. {
  46. return(cnt = 0);
  47. }
  48. ARRAY_TYPE zero_param()
  49. {
  50. return(cnt++);
  51. }
  52. ARRAY_TYPE one_param(y)
  53. ARRAY_TYPE y;
  54. {
  55. ARRAY_TYPE j,k;
  56. j = y;
  57. k = NUM;
  58. j=k;
  59. y=j;
  60. j=NUM;
  61. y=j;
  62. return(y);
  63. }
  64. ARRAY_TYPE two_param(x,y)
  65. ARRAY_TYPE x,y;
  66. {
  67. return(x*2-y+2);
  68. }
  69.  
  70. /* index needed */
  71. ARRAY_TYPE i,j,k;
  72. /* arrays needed */
  73. ARRAY_TYPE i1[NUM],i2[NUM],i3[NUM];
  74.  
  75. main()
  76. {
  77.  
  78. ARR_IF1
  79. {        /* if this curly brace causes an error, try defining */    
  80.         /* ARR_IF_NEEDED to 1 */
  81. i = NUM;        /* do something */
  82. } ARR_IF2
  83.  
  84.  
  85. #if TEST_FILL
  86.     test_fill();
  87. #endif
  88. #if TEST_INFO
  89.     test_info();
  90. #endif
  91. #if TEST_UNOP
  92.     test_unop();
  93. #endif
  94. #if TEST_BINOP
  95.     test_binop();
  96. #endif
  97.  
  98. puts("\n\n\n\nAll Tests Passed\n\n\n");
  99.  
  100.  
  101. exit(0);
  102. }
  103.  
  104.  
  105. #if TEST_FILL
  106.  
  107.  
  108. test_fill()
  109. {
  110.  
  111.  
  112. /* first test fill operations, needed for other tests */
  113. puts("\nTesting Fill Operations:");
  114.  
  115. a_index(NUM,i1);    /* fill with index */
  116. for ( i=0; i<NUM; ++i )
  117.     if ( !( i1[i] == (ARRAY_TYPE)  i ) )
  118.         a_error("index Not Work:",i);
  119.  
  120. putchar('1');
  121.  
  122. a_indoff(NUM,i2,1);    /* fill with index + 1 */
  123. for ( i=0; i < NUM; ++i )
  124.     if ( ! ( i2[i] == (ARRAY_TYPE)  (i+1) ) )
  125.         a_error("indoff Not Work:",i);
  126.  
  127. putchar('2');
  128.  
  129. a_assign(NUM,i3,5);    /* fill with 5 */
  130. for ( i=0; i<NUM; ++i )
  131.     if ( ! ( i3[i] == (ARRAY_TYPE)  5 ) )
  132.         a_error("indassign Not Work:",i);
  133.  
  134. putchar('3');
  135.  
  136. a_i_scale(NUM,i1,5,4);    /* fill with i*5+4 */
  137. for ( i=0; i<NUM; ++i )
  138.     if ( ! ( i1[i] == (ARRAY_TYPE)  (i*5+4) ) )
  139.         a_error("a_i_scale Not Work:",i);
  140.  
  141. putchar('4');
  142.  
  143. a_fill(NUM,i2,-5,5);
  144. for ( i=0; i<NUM; ++i )
  145.     if ( ! ( i2[i] == (ARRAY_TYPE)  (-5+(i* 10)/NUM) ) )
  146.         a_error("a_fill Not Work:",i);
  147. if ( ! ( i2[0] == (ARRAY_TYPE)  -5 ) )
  148.     a_error("a_fill Not Work:",0);
  149.  
  150.  
  151. putchar('5');
  152.  
  153. a_t_fill(NUM,i3,-6,-1,ARRAY_TYPE);
  154. for ( i=0; i<NUM; ++i )
  155.     if ( ! ( i3[i] == (k= (ARRAY_TYPE)  (-6+((ARRAY_TYPE)i* 5 )/NUM)) ) ) {
  156.         PRV(i);
  157.         PRV(i3[i]);
  158.         PRV(((ARRAY_TYPE)  (-6+((ARRAY_TYPE)i* 5 )/NUM)) );
  159.         a_error("a_t_fill Not Work:",i);
  160.     }
  161. if ( ! ( i3[0] == (ARRAY_TYPE)  -6 ) )
  162.     a_error("a_t_fill Not Work:",0);
  163.  
  164. putchar('6');
  165.  
  166. a_ifill(NUM,i1,-3,15);
  167. for ( i=0; i<NUM; ++i )
  168.     if ( ! ( i1[i] == (ARRAY_TYPE)  (-3+(i* 18)/(NUM-1)) ) )
  169.         a_error("a_ifill Not Work:",i);
  170. if ( ! ( i1[0] == (ARRAY_TYPE)  -3 ) )
  171.     a_error("a_ifill Not Work:",0);
  172. if ( ! ( i1[NUM-1] == (ARRAY_TYPE)  15 ) )
  173.     a_error("a_ifill Not Work:",1);
  174.  
  175.  
  176. putchar('7');
  177.  
  178. a_t_ifill(NUM,i2,5,-13,ARRAY_TYPE);
  179. for ( i=0; i<NUM; ++i )
  180.     if ( ! ( i2[i] == (ARRAY_TYPE)  (5 +((ARRAY_TYPE)i* -18)/(NUM-1)) ) )
  181.         a_error("a_t_ifill Not Work:",i);
  182. if ( ! ( i2[0] == (ARRAY_TYPE)  5  ) )
  183.     a_error("a_t_ifill Not Work:",0);
  184. if ( ! ( i2[NUM-1] == (ARRAY_TYPE)  -13 ) )
  185.     a_error("a_t_ifill Not Work:",0);
  186.  
  187. putchar('8');
  188.  
  189. reset_zero_param();
  190. a_f_fun(NUM,i3,zero_param);
  191. reset_zero_param();
  192. for ( i=NUM; i--; )
  193.     if ( ! ( i3[i] == (ARRAY_TYPE)  zero_param() ) )
  194.         a_error("a_f_fun Not Work:",i);
  195.  
  196. putchar('9');
  197.  
  198.  
  199. a_i_fun(NUM,i1,one_param);
  200. for ( i=0; i<NUM; ++i )
  201.     if ( ! ( i1[i] == one_param(i) ) )
  202.         a_error("a_i_fun Not Work:",i);
  203.  
  204.  
  205. putchar('A');
  206.  
  207. a_t_i_fun(NUM,i2,one_param,ARRAY_TYPE);
  208. for ( i=0; i<NUM; ++i )
  209.     if ( ! ( i2[i] == (ARRAY_TYPE)  one_param((ARRAY_TYPE)i) ) )
  210.         a_error("a_t_i_fun Not Work:",i);
  211.  
  212.  
  213. /* successful */
  214. puts(".\tSuccessful");
  215.  
  216. return(0);
  217. }
  218.  
  219.  
  220. #endif
  221. #if TEST_INFO
  222.  
  223.  
  224. test_info()
  225. {
  226.  
  227. /* now set up arrays for info testing */
  228. a_fill(NUM,i1,-10,10);
  229. a_indoff(NUM,i2,- NUM);
  230. a_i_scale(NUM,i3,2,-25);
  231.  
  232. /* start info */
  233. puts("\nTesting Info");
  234.  
  235.  
  236.  
  237.  
  238. a_sum(NUM,j,i1);
  239. k = i1[0]; for ( i=1; i<NUM; ++i ) k += i1[i];
  240. if ( ! ( j == (ARRAY_TYPE)  k ) )
  241.     a_error("Sum Not Work:",j-k);
  242.  
  243. putchar('1');
  244.  
  245. a_prod(NUM,j,i2);
  246. k = i2[0]; for ( i=1; i<NUM; ++i ) k *= i2[i];
  247. if ( ! ( j == (ARRAY_TYPE)  k ) )
  248.     a_error("Prod Not Work:",j-k);
  249.  
  250. putchar('2');
  251.  
  252. a_max(NUM,j,i3);
  253. if ( ! ( j == (ARRAY_TYPE)  (2*(NUM-1) + -25) ) )
  254.     a_error("Max Not Work:",j-k);
  255.  
  256. putchar('3');
  257.  
  258.  
  259. a_min(NUM,j,i1);
  260. if ( ! ( j == (ARRAY_TYPE)  -10 ) )
  261.     a_error("Min Not Work:",j-k);
  262.  
  263. putchar('4');
  264.  
  265. a_minmax(NUM,j,k,i2)
  266. if ( ! ( ( j == (ARRAY_TYPE)  (-NUM) ) && ( k == (ARRAY_TYPE)  -1) ) )
  267.     a_error("MinMax Not Work:",i2[NUM-1]);
  268.  
  269. /* successful */
  270. puts(".\tSuccessful");
  271. return(0);
  272. }
  273.  
  274. #endif
  275. #if TEST_UNOP
  276.  
  277. test_unop()
  278. {
  279.  
  280. /* now set up arrays for unop testing */
  281. a_ifill(NUM,i1,-NUM , NUM ); 
  282. a_index(NUM,i2);
  283. a_indoff(NUM,i3,-1);
  284.  
  285.  
  286. puts("\nStarting Unop");
  287.  
  288. a_cpy(NUM,i2,i1);
  289. for ( i=0; i<NUM; ++i )
  290.     if ( ! ( i1[i] == (ARRAY_TYPE)  i2[i] ) )
  291.         a_error("a_cpy Not Work:",i);
  292.  
  293. putchar('1');
  294.  
  295. a_neg(NUM,i2,i3);
  296. for ( i=0; i<NUM; ++i )
  297.     if ( ! ( i2[i] == (ARRAY_TYPE)  - i3[i] ) )
  298.         a_error("a_neg Not Work:",i);
  299.  
  300. putchar('2');
  301.  
  302. a_abs(NUM,i3,i1);
  303. for ( i=0; i<NUM; ++i )
  304.     if ( ! (i3[i] == (ARRAY_TYPE)  ( (i1[i] < 0) ? (- i1[i]) : i1[i] ) ) )
  305.         a_error("a_abs Not Work:",i);
  306.  
  307. putchar('3');
  308.  
  309. a_scale(NUM,i2,i1,10,5);
  310. for ( i=0; i<NUM; ++i )
  311.     if ( ! (i2[i] == (ARRAY_TYPE)  (i1[i]*10 + 5) ) )
  312.         a_error("a_scale Not Work:",i);
  313.  
  314. putchar('4');
  315.  
  316. a_rsum(NUM,i3,i2);
  317. for ( k=i=0; i<NUM; ++i ) {
  318.     k += i2[i];
  319.     if ( ! (i3[i] == (ARRAY_TYPE)  k) )
  320.         a_error("a_rsum Not Work:",i);
  321. }
  322. putchar('5');
  323.  
  324. a_rprod(NUM,i1,i3);
  325. k=1;
  326. for ( i=0; i<NUM; ++i ) {
  327.     k *= i3[i];
  328.     if ( ! (i1[i] == (ARRAY_TYPE)  k) )
  329.         a_error("a_rprod Not Work:",i);
  330. }
  331. putchar('6');
  332.  
  333. a_rmin(NUM,i1,i2);
  334. k=i2[0];
  335. for ( i=1; i<NUM; ++i ) {
  336.     k = ((k<i2[i])?k:i2[i]);
  337.     if ( ! (i1[i] == (ARRAY_TYPE)  k) )
  338.         a_error("a_rmin Not Work:",i);
  339. }
  340. putchar('7');
  341.  
  342. a_rmax(NUM,i3,i2);
  343. k=i2[0];
  344. for ( i=1; i<NUM; ++i ) {
  345.     k = ((k>i2[i])?k:i2[i]);
  346.     if ( ! (i3[i] == (ARRAY_TYPE)  k) )
  347.         a_error("a_rmax Not Work:",i);
  348. }
  349. putchar('8');
  350.  
  351.  
  352. a_fun(NUM,i3,i2,one_param);
  353. for ( i=0; i<NUM; ++i ) {
  354.     if ( ! (i3[i] == (ARRAY_TYPE)  one_param(i2[i])) )
  355.         a_error("a_fun Not Work:",i);
  356. }
  357. putchar('9');
  358.  
  359. a_t_fun(NUM,i2,i1,one_param,ARRAY_TYPE);
  360. for ( i=0; i<NUM; ++i ) {
  361.     if ( ! (i2[i] == (ARRAY_TYPE)  one_param((ARRAY_TYPE)i1[i])) )
  362.         a_error("a_t_fun Not Work:",i);
  363. }
  364. putchar('A');
  365.  
  366. /* successful */
  367. puts(".\tSuccessful");
  368.  
  369. return(0);
  370. }
  371.  
  372. #endif
  373. #if TEST_BINOP
  374.  
  375.  
  376. test_binop()
  377. {
  378. /* now set up arrays for unop testing */
  379. a_ifill(NUM,i1, NUM ,-NUM ); 
  380. a_indoff(NUM,i2,-NUM/2);
  381. a_i_scale(NUM,i3,-1,-5);
  382.  
  383.  
  384. puts("\nStarting Binop");
  385.  
  386. test_a_binop();
  387. test_b_binop();
  388. test_c_binop();
  389. test_d_binop();
  390.  
  391. /* successful */
  392. puts(".\tSuccessful");
  393.  
  394. return(0);
  395. }
  396.  
  397.  
  398. test_a_binop()
  399. {
  400.  
  401. aa_add(NUM,i1,i2,i3);
  402. for ( i=0; i<NUM; ++i ) {
  403.     if ( ! (i1[i] == (ARRAY_TYPE)  (i2[i]+i3[i])) )
  404.         a_error("aa_add Not Work:",i);
  405. }
  406. ac_add(NUM,i1,i2,5 );
  407. for ( i=0; i<NUM; ++i ) {
  408.     if ( ! (i1[i] == (ARRAY_TYPE)  (i2[i] + 5 )) )
  409.         a_error("ac_add Not Work:",i);
  410. }
  411. ca_add(NUM,i1,7 ,i3);
  412. for ( i=0; i<NUM; ++i ) {
  413.     if ( ! (i1[i] == (ARRAY_TYPE)  (7 + i3[i])) )
  414.         a_error("ca_add Not Work:",i);
  415. }
  416. putchar('0');
  417.  
  418. aa_mul(NUM,i1,i2,i3);
  419. for ( i=0; i<NUM; ++i ) {
  420.     if ( ! (i1[i] == (ARRAY_TYPE)  (i2[i] * i3[i])) )
  421.         a_error("aa_mul Not Work:",i);
  422. }
  423. ac_mul(NUM,i1,i2,5 );
  424. for ( i=0; i<NUM; ++i ) {
  425.     if ( ! (i1[i] == (ARRAY_TYPE)  (i2[i] * 5 )) )
  426.         a_error("ac_mul Not Work:",i);
  427. }
  428. ca_mul(NUM,i1,7 ,i3);
  429. for ( i=0; i<NUM; ++i ) {
  430.     if ( ! (i1[i] == (ARRAY_TYPE)  (7 * i3[i])) )
  431.         a_error("ca_mul Not Work:",i);
  432. }
  433. putchar('1');
  434.  
  435.  
  436. aa_sub(NUM,i1,i2,i3);
  437. for ( i=0; i<NUM; ++i ) {
  438.     if ( ! (i1[i] == (ARRAY_TYPE)  (i2[i] - i3[i])) )
  439.         a_error("aa_sub Not Work:",i);
  440. }
  441. ac_sub(NUM,i1,i2,5 );
  442. for ( i=0; i<NUM; ++i ) {
  443.     if ( ! (i1[i] == (ARRAY_TYPE)  (i2[i] - 5 )) )
  444.         a_error("ac_sub Not Work:",i);
  445. }
  446. ca_sub(NUM,i1,7 ,i3);
  447. for ( i=0; i<NUM; ++i ) {
  448.     if ( ! (i1[i] == (ARRAY_TYPE)  (7 - i3[i])) )
  449.         a_error("ca_sub Not Work:",i);
  450. }
  451. putchar('2');
  452.  
  453. a_assign(NUM,i3,2);
  454. aa_div(NUM,i1,i2,i3);
  455. for ( i=0; i<NUM; ++i ) {
  456.     if ( ! (i1[i] == ((ARRAY_TYPE)  (i2[i] / i3[i]))) )
  457.         a_error("aa_div Not Work:",i);
  458. }
  459. ac_div(NUM,i1,i2,4 );
  460. for ( i=0; i<NUM; ++i ) {
  461.     if ( ! (i1[i] == (ARRAY_TYPE)  (i2[i] / 4 )) )
  462.         a_error("ac_div Not Work:",i);
  463. }
  464. ca_div(NUM,i1,-2,i3);
  465. for ( i=0; i<NUM; ++i ) {
  466.     if ( ! (i1[i] == (ARRAY_TYPE)  (-2/ i3[i])) )
  467.         a_error("ca_div Not Work:",i);
  468. }
  469. putchar('3');
  470.  
  471. #if    TEST_MOD
  472.  
  473. aa_mod(NUM,i1,i2,i3);
  474. for ( i=0; i<NUM; ++i ) {
  475.     if ( ! (i1[i] == (ARRAY_TYPE)  (i2[i] % i3[i])) )
  476.         a_error("aa_mod Not Work:",i);
  477. }
  478. ac_mod(NUM,i1,i2,5 );
  479. for ( i=0; i<NUM; ++i ) {
  480.     if ( ! (i1[i] == (ARRAY_TYPE)  (i2[i] % 5 )) )
  481.         a_error("ac_mod Not Work:",i);
  482. }
  483. ca_mod(NUM,i1,7 ,i3);
  484. for ( i=0; i<NUM; ++i ) {
  485.     if ( ! (i1[i] == (ARRAY_TYPE)  (7 % i3[i])) )
  486.         a_error("ca_mod Not Work:",i);
  487. }
  488. putchar('4');
  489.  
  490. #endif
  491.  
  492.  
  493. aa_equ(NUM,i1,i2,i3);
  494. for ( i=0; i<NUM; ++i ) {
  495.     if ( ! (i1[i] == (ARRAY_TYPE)  (i2[i] == (ARRAY_TYPE)  i3[i])) )
  496.         a_error("aa_equ Not Work:",i);
  497. }
  498. ac_equ(NUM,i1,i2,5 );
  499. for ( i=0; i<NUM; ++i ) {
  500.     if ( ! (i1[i] == (ARRAY_TYPE)  (i2[i] == (ARRAY_TYPE)  5 )) )
  501.         a_error("ac_equ Not Work:",i);
  502. }
  503. ca_equ(NUM,i1,7 ,i3);
  504. for ( i=0; i<NUM; ++i ) {
  505.     if ( ! (i1[i] == (ARRAY_TYPE)  (7 == (ARRAY_TYPE)  i3[i])) )
  506.         a_error("ca_equ Not Work:",i);
  507. }
  508. putchar('5');
  509.  
  510. aa_geq(NUM,i1,i2,i3);
  511. for ( i=0; i<NUM; ++i ) {
  512.     if ( ! (i1[i] == (ARRAY_TYPE)  (i2[i] >= i3[i])) )
  513.         a_error("aa_geq Not Work:",i);
  514. }
  515. ac_geq(NUM,i1,i2,5 );
  516. for ( i=0; i<NUM; ++i ) {
  517.     if ( ! (i1[i] == (ARRAY_TYPE)  (i2[i] >= 5 )) )
  518.         a_error("ac_geq Not Work:",i);
  519. }
  520. ca_geq(NUM,i1,7 ,i3);
  521. for ( i=0; i<NUM; ++i ) {
  522.     if ( ! (i1[i] == (ARRAY_TYPE)  (7 >= i3[i])) )
  523.         a_error("ca_geq Not Work:",i);
  524. }
  525. putchar('6');
  526.  
  527. return(0);
  528. }
  529.  
  530. test_b_binop()
  531. {
  532.  
  533.  
  534. aa_gtr(NUM,i1,i2,i3);
  535. for ( i=0; i<NUM; ++i ) {
  536.     if ( ! (i1[i] == (ARRAY_TYPE)  (i2[i] > i3[i])) )
  537.         a_error("aa_gtr Not Work:",i);
  538. }
  539. ac_gtr(NUM,i1,i2,5 );
  540. for ( i=0; i<NUM; ++i ) {
  541.     if ( ! (i1[i] == (ARRAY_TYPE)  (i2[i] > 5 )) )
  542.         a_error("ac_gtr Not Work:",i);
  543. }
  544. ca_gtr(NUM,i1,7 ,i3);
  545. for ( i=0; i<NUM; ++i ) {
  546.     if ( ! (i1[i] == (ARRAY_TYPE)  (7 > i3[i])) )
  547.         a_error("ca_gtr Not Work:",i);
  548. }
  549. putchar('7');
  550.  
  551.  
  552. aa_leq(NUM,i1,i2,i3);
  553. for ( i=0; i<NUM; ++i ) {
  554.     if ( ! (i1[i] == (ARRAY_TYPE)  (i2[i] <= i3[i])) )
  555.         a_error("aa_leq Not Work:",i);
  556. }
  557. ac_leq(NUM,i1,i2,5 );
  558. for ( i=0; i<NUM; ++i ) {
  559.     if ( ! (i1[i] == (ARRAY_TYPE)  (i2[i] <= 5 )) )
  560.         a_error("ac_leq Not Work:",i);
  561. }
  562. ca_leq(NUM,i1,7 ,i3);
  563. for ( i=0; i<NUM; ++i ) {
  564.     if ( ! (i1[i] == (ARRAY_TYPE)  (7 <= i3[i])) )
  565.         a_error("ca_leq Not Work:",i);
  566. }
  567. putchar('8');
  568.  
  569. aa_les(NUM,i1,i2,i3);
  570. for ( i=0; i<NUM; ++i ) {
  571.     if ( ! (i1[i] == (ARRAY_TYPE)  (i2[i] < i3[i])) )
  572.         a_error("aa_les Not Work:",i);
  573. }
  574. ac_les(NUM,i1,i2,5 );
  575. for ( i=0; i<NUM; ++i ) {
  576.     if ( ! (i1[i] == (ARRAY_TYPE)  (i2[i] < 5 )) )
  577.         a_error("ac_les Not Work:",i);
  578. }
  579. ca_les(NUM,i1,7 ,i3);
  580. for ( i=0; i<NUM; ++i ) {
  581.     if ( ! (i1[i] == (ARRAY_TYPE)  (7 < i3[i])) )
  582.         a_error("ca_les Not Work:",i);
  583. }
  584. putchar('9');
  585.  
  586.  
  587. return(0);
  588. }
  589.  
  590. test_c_binop()
  591. {
  592. aa_min(NUM,i1,i2,i3);
  593. for ( i=0; i<NUM; ++i ) {
  594.     if ( ! (i1[i] == (ARRAY_TYPE)  ((i2[i] < i3[i])?i2[i]:i3[i])) )
  595.         a_error("aa_min Not Work:",i);
  596. }
  597. ac_min(NUM,i1,i2,5 );
  598. for ( i=0; i<NUM; ++i ) {
  599.     if ( ! (i1[i] == (ARRAY_TYPE)  ((i2[i] < 5 )?i2[i]:5)) )
  600.         a_error("ac_min Not Work:",i);
  601. }
  602. ca_min(NUM,i1,7 ,i3);
  603. for ( i=0; i<NUM; ++i ) {
  604.     if ( ! (i1[i] == (ARRAY_TYPE)  ((7 < i3[i])?7:i3[i])) )
  605.         a_error("ca_min Not Work:",i);
  606. }
  607. putchar('A');
  608.  
  609.  
  610. aa_max(NUM,i1,i2,i3);
  611. for ( i=0; i<NUM; ++i ) {
  612.     if ( ! (i1[i] == (ARRAY_TYPE)  ((i2[i] > i3[i])?i2[i]:i3[i])) )
  613.         a_error("aa_max Not Work:",i);
  614. }
  615. ac_max(NUM,i1,i2,5 );
  616. for ( i=0; i<NUM; ++i ) {
  617.     if ( ! (i1[i] == (ARRAY_TYPE)  ((i2[i] > 5 )?i2[i]:5)) )
  618.         a_error("ac_max Not Work:",i);
  619. }
  620. ca_max(NUM,i1,7 ,i3);
  621. for ( i=0; i<NUM; ++i ) {
  622.     if ( ! (i1[i] == (ARRAY_TYPE)  ((7 > i3[i])?7:i3[i])) )
  623.         a_error("ca_max Not Work:",i);
  624. }
  625. putchar('B');
  626.  
  627.  
  628. return(0);
  629. }
  630.  
  631. test_d_binop()
  632. {
  633.  
  634.  
  635. aa_fun(NUM,i1,i2,i3,two_param);
  636. for ( i=0; i<NUM; ++i ) {
  637.     if ( ! (i1[i] == (ARRAY_TYPE)  two_param(i2[i] , i3[i])) )
  638.         a_error("aa_fun Not Work:",i);
  639. }
  640. ac_fun(NUM,i1,i2,5,two_param );
  641. for ( i=0; i<NUM; ++i ) {
  642.     if ( ! (i1[i] == (ARRAY_TYPE)  two_param(i2[i],5)) )
  643.         a_error("ac_fun Not Work:",i);
  644. }
  645. ca_fun(NUM,i1,7 ,i3,two_param);
  646. for ( i=0; i<NUM; ++i ) {
  647.     if ( ! (i1[i] == (ARRAY_TYPE)  two_param(7 , i3[i])) )
  648.         a_error("ca_fun Not Work:",i);
  649. }
  650. putchar('C');
  651.  
  652. aa_t_fun(NUM,i1,i2,i3,two_param,ARRAY_TYPE);
  653. for ( i=0; i<NUM; ++i ) {
  654.     if ( ! (i1[i] == (ARRAY_TYPE)  two_param((ARRAY_TYPE)i2[i] , (ARRAY_TYPE)i3[i])) )
  655.         a_error("aa_t_fun Not Work:",i);
  656. }
  657. ac_t_fun(NUM,i1,i2,5,two_param,ARRAY_TYPE );
  658. for ( i=0; i<NUM; ++i ) {
  659.     if ( ! (i1[i] == (ARRAY_TYPE)  two_param((ARRAY_TYPE)i2[i],(ARRAY_TYPE)5)) )
  660.         a_error("ac_t_fun Not Work:",i);
  661. }
  662. ca_t_fun(NUM,i1,7 ,i3,two_param,ARRAY_TYPE);
  663. for ( i=0; i<NUM; ++i ) {
  664.     if ( ! (i1[i] == (ARRAY_TYPE)  two_param((ARRAY_TYPE)7 , (ARRAY_TYPE)i3[i])) )
  665.         a_error("ca_t_fun Not Work:",i);
  666. }
  667. putchar('D');
  668. return(0);
  669. }
  670.  
  671. #endif
  672.  
  673. /* end */
  674.